package sanrenxing.ForePaper.dao.impl;

import com.mysql.cj.api.jdbc.JdbcConnection;
import com.mysql.cj.jdbc.PreparedStatementWrapper;
import org.omg.SendingContext.RunTime;
import sanrenxing.ForePaper.dao.ForePaperDao;
import sanrenxing.ForePaper.domain.ExamScore;
import sanrenxing.ForePaper.domain.PaperStateMsg;
import sanrenxing.ForePaper.domain.ExamSubject;
import sanrenxing.utils.JdbcUtils;

import javax.naming.event.ObjectChangeListener;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * @author Administrator
 * @date 2020/10/3 15:53
 * 编辑者：邓志强
 * 功能：
 */
public class ForePaperDaoImpl implements ForePaperDao {

    /**
     * 判断学员是否有考试
     * @param stuId
     * @return
     */
    @Override
    public boolean checkState(String stuId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        //定义结果集对象
        ResultSet rs=null;
        try {
            //实例化连接对象
            conn= JdbcUtils.getConnection();
            //创建sql语句
            String sql="select * from statu where stuId=?";
            //实例化预编译语句
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setString(1,stuId);
            //执行sql
            rs=pstmt.executeQuery();
            //判断结果集是否有值
            if (rs.next()){
                //如果有值，则返回true
                return true;
            }
        } catch (SQLException e) {
            //抛出运行时异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流对象
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回false
        return false;
    }

    /**
     * 展示试卷状态
     *
     * @param stuId
     * @return
     */
    @Override
    public PaperStateMsg showState(String stuId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        //定义结果集对象
        ResultSet rs=null;
        //定义试卷状态信息对象
        PaperStateMsg psm=null;
        try {
            //实例化连接对象
            conn=JdbcUtils.getConnection();
            //创建sql语句
            String sql="SELECT statu.conditionId conditionId, course.courseName courseName,class.className className,paper.examDate examDate,paper.beginTime beginTime,paper.finishTime finishTime FROM " +
                    "statu JOIN course ON (SELECT paper.courseId FROM statu JOIN paper ON statu.paperId=paper.paperId " +
                    "WHERE stuId=?)=course.courseId JOIN class ON class.classId=statu.classId JOIN paper ON " +
                    "paper.paperId=statu.paperId WHERE statu.stuId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setString(1,stuId);
            pstmt.setString(2,stuId);
            //运行sql
            rs=pstmt.executeQuery();
            //判断结果集是否有值
            if (rs.next()){
                //创建试卷状态信息对象
                psm=new PaperStateMsg();
                //给psm对象中的变量赋值
                psm.setConditionId(rs.getInt("conditionId"));
                psm.setCourseName(rs.getString("courseName"));
                psm.setClassName(rs.getString("className"));
                psm.setExamDate(rs.getString("examDate"));
                psm.setBeginTime(rs.getString("beginTime"));
                psm.setFinishTime(rs.getString("finishTime"));
                //返回对象
                return psm;
            }
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流对象
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空
        return null;
    }

    /**
     * 查询学员考试状态的试卷的题目编号和考试结束时间
     *
     * @param stuId
     * @return
     */
    @Override
    public Map<String,Object> subjectNum(String stuId) {
        //定义一个map集合
        Map<String,Object> map=new HashMap<String,Object>();
        //定义连接对象
        Connection conn=null;
        //定义一个预编译对象
        PreparedStatement pstmt=null;
        //定义一个结果集对象
        ResultSet rs=null;
        try {
            //实例化连接对象
            conn=JdbcUtils.getConnection();
            //创建sql语句
            String sql="SELECT statu.paperId paperId,statu.conditionId conditionId ,paper.subjectIds subjectIds,paper.finishTime finishTime FROM statu JOIN paper ON (SELECT statu.paperId FROM statu WHERE " +
                    "statu.stuId=?)=paper.paperId WHERE statu.stuId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setString(1,stuId);
            pstmt.setString(2,stuId);
            //执行sql语句
            rs=pstmt.executeQuery();
            //判断结果集中是否有数据
            if (rs.next()){
                //定义一个变量接收结果集中的conditionId
                String conditionId=rs.getString("conditionId");
                //定义一个变量接收结果集中的subjectIds
                String subjectIds=rs.getString("subjectIds");
                //定义一个变量接收结果集中的finishTime
                String finishTime=rs.getString("finishTime");
                //将定义的变量全部存储到map集合当中
                map.put("conditionId",conditionId);
                map.put("subjectIds",subjectIds);
                map.put("finishTime",finishTime);
                //返回map集合
                return map;
            }
        } catch (SQLException e) {
            //收工抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空
        return null;
    }

    /**
     * 通过题目编号取出题目
     *
     * @param subjectId
     * @return
     */
    @Override
    public ExamSubject getSubject(String subjectId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        //定义结果集对象
        ResultSet rs=null;
        try {
            //创建连接对象
            conn=JdbcUtils.getConnection();
            //定义sql语句
            String sql="select subjectId,subjectType,stem,optionA,optionB,optionC,optionD," +
                    "optionE,optionF,optionG,optionH,correct from subjects where subjectId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setString(1,subjectId);
            //运行sql
            rs=pstmt.executeQuery();
            //判断结果集中是否有数据
            if (rs.next()){
                //创建考试题目对象
                ExamSubject examSubject =new ExamSubject();
                //对考试题目对象中的变量赋值
                examSubject.setSubjectId(rs.getInt("subjectId"));
                examSubject.setSubjectType(rs.getString("subjectType"));
                examSubject.setStem(rs.getString("stem"));
                //创建水随机数
                Random random=new Random();
                //创建选择数组
                String[] ah={"A","B","C","D","E","F","G","H"};
                //定义一个选项存储不为空选项的字母
                String notNull="";
                //排除空选项，空选择不需要打乱顺序
                for (String s:ah){
                    //取得选项的值
                    String selects=rs.getString("option"+s);
                    //判断是否有值
                    if (!selects.equals("") && !selects.equals(null)){
                        //将遍历的选项加起来
                        notNull+=s;
                    }
                }
                //获得不为空选项个数
                int leng=notNull.length();
                //调用生成随机数方法，并传参需要生成随机数的个数
                int[] randomArr=makeRandom(leng);
                //定义一个i等于0
                int i=0;
                //定义一个保存正确答案状态的int类型数据
                String correctNum="";
                //获取正确答案
                String correct=rs.getString("correct");
                //通过循环，以数字类型的数据保存正确答案状态
                for (int j = 0; j <ah.length ; j++) {
                    if (correct.length()==1 && correct.equals(ah[j])){//单选题情况保存正确答案状态
                        correctNum=String.valueOf(j);
                        break;
                    }else if (correct.length()>1){//多选题情况保存正确答案状态
                        for (int a=0;a<correct.length();a++){
                            if (String.valueOf(correct.charAt(a)).equals(ah[j])){//将多个答案依次转换为数字状态
                                correctNum+=String.valueOf(j)+",";
                            }
                        }
                    }
                }
                //定义字符串数组
                String[] correctArr=null;
                //将正确答案状态字符串转换为字符串数组
                if (correctNum.length()>1){
                    //去除最后一个逗号
                    correctNum=correctNum.substring(0,correctNum.length()-1);
                    correctArr=correctNum.split(",");
                }
                //定义一个保存正确答案的字符串
                String trues="";
                //将非空选项保存到字符数组中
                char[] notNullArr = notNull.toCharArray();
                for (char c:notNullArr){
                    //将char转换为String，方便使用equals
                    String sc=String.valueOf(c);
                    //将随机好的数字状态取出
                    int num=randomArr[i];
                    i++;
                    if (sc.equals("A")){
                        //将随机题目保存到选项当中
                        examSubject.setOptionA(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="A";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="A";
                                }
                            }
                        }

                    }else if (sc.equals("B")){
                        examSubject.setOptionB(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="B";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="B";
                                }
                            }
                        }
                    }else if (sc.equals("C")){
                        examSubject.setOptionC(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="C";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="C";
                                }
                            }
                        }
                    }else if (sc.equals("D")){
                        examSubject.setOptionD(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="D";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="D";
                                }
                            }
                        }
                    }else if (sc.equals("E")){
                        examSubject.setOptionE(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="E";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="E";
                                }
                            }
                        }
                    }else if (sc.equals("F")){
                        examSubject.setOptionF(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="F";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="F";
                                }
                            }
                        }
                    }else if (sc.equals("G")){
                        examSubject.setOptionG(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="G";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="G";
                                }
                            }
                        }
                    }else if (sc.equals("H")){
                        examSubject.setOptionH(rs.getString("option"+notNullArr[num]+""));
                        //判断正确答案的状态和随机后的答案的状态是否相等，如果相等，则保存正确答案
                        if (correctArr==null){//单选题情况
                            if (Integer.parseInt(correctNum)==num){
                                trues="H";
                            }
                        }else{//多选题情况
                            for (int v=0;v<correctArr.length;v++){
                                if (Integer.parseInt(correctArr[v])==num){
                                    trues+="H";
                                }
                            }
                        }
                    }
                }

                //将正确答案保存到对象当中
                examSubject.setCorrect(trues);
                //返回一个题目对象
                return examSubject;
            }
        } catch (SQLException e) {
            new RuntimeException(e.getMessage(),e);
        }finally{
            JdbcUtils.close(rs,pstmt,conn);
        }
        return null;
    }

    /**
     * 生成随机数方法,返回随机选项需要的数组
     *
     * @param length
     * @return
     */
    @Override
    public int[] makeRandom(int length) {
        int[] a = new int[length];//初始化数组
        Random random = new Random();
        int count = 0;//记录有效的随机数个数
        while(count < a.length){
            boolean flag = true;//用来标志的变量
            int r = random.nextInt(length)+1;
            for(int i=0;i<a.length;i++){
                if(r == a[i]){
                    flag = false;
                    break;
                }
            }
            if(flag){
                a[count] = r;//为什么要减一呢，因为通过上面的判断是不能取到0的，但是根据长度获取长度类的数字需要0，所以减一。
                //System.out.println(r);
                count++;
            }
        }
        //将原有的值依次减一
        for (int j=0;j<a.length;j++){
            a[j]=a[j]-1;
        }
        return a;
    }

    /**
     * 修改学员考试状态
     *
     *
     */
    @Override
    public void updateState(int conditionId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        try {
            //创建连接对象
            conn=JdbcUtils.getConnection();
            //创建sql语句
            String sql="UPDATE statu SET conditions='在考' WHERE conditionId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,conditionId);
            //执行sql
            pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(null,pstmt,conn);
        }
    }

    /**
     * 删除学员考试状态
     *
     * @param conditionId
     */
    @Override
    public void deleteState(int conditionId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        try {
            //创建连接对象
            conn=JdbcUtils.getConnection();
            //创建sql语句
            String sql="delete from statu where conditionId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,conditionId);
            //执行sql
            pstmt.executeUpdate();
        } catch (SQLException e) {
            //手动抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(null,pstmt,conn);
        }
    }

    /**
     * 查询成绩，为阅卷后添加成绩做查询
     * @return
     */
    @Override
    public ExamScore findScore(int conditionId,int score) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        //定义结果集对象
        ResultSet rs=null;
        try {
            //实例化连接对象
            conn=JdbcUtils.getConnection();
            //创建sql语句
            String sql="SELECT p.courseId courseId,s.stuId stuId,s.classId classId,s.paperId paperId FROM statu s JOIN paper p ON s.paperId=p.paperId " +
                    " WHERE s.conditionId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给张占位符赋值
            pstmt.setInt(1,conditionId);
            //运行sql语句
            rs=pstmt.executeQuery();
            //判断结果集中是否有数据
            if (rs.next()){
                //创建考试分数对象
                ExamScore examScore=new ExamScore();
                //为考试分数对象中变量赋值
                examScore.setCourseId(rs.getInt("courseId"));
                examScore.setStuId(rs.getString("stuId"));
                examScore.setClassId(rs.getInt("classId"));
                examScore.setPaperId(rs.getInt("paperId"));
                examScore.setGrades(score);
                //返回考试分数对象
                return examScore;
            }
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空
        return null;
    }

    /**
     * 自动阅卷后添加考试成绩
     *
     *
     */
    @Override
    public void addExamScore(ExamScore examScore) {
        //定义连接对象
        Connection conn=null;
        //定义预编译语句对象
        PreparedStatement pstmt=null;
        try {
            //实例化连接对象
            conn=JdbcUtils.getConnection();
            //编写sql语句
            String sql="insert into score(courseId,stuId,classId,paperId,grades) values(?,?,?,?,?)";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,examScore.getCourseId());
            pstmt.setString(2,examScore.getStuId());
            pstmt.setInt(3,examScore.getClassId());
            pstmt.setInt(4,examScore.getPaperId());
            pstmt.setInt(5,examScore.getGrades());
            //执行sql
            pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(null,pstmt,conn);
        }
    }

    /**
     * 查询补考信息，为阅卷后添加补考信息做查询
     *
     * @param conditionId
     * @return
     */
    @Override
    public Map<String, Object> findReexams(int conditionId) {
        //创建map对象
        Map<String, Object> map=new HashMap<>();
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        //定义结果集对象
        ResultSet rs=null;
        try {
            //实例化连接对象
            conn= JdbcUtils.getConnection();
            //创建sql语句
            String sql="SELECT s.stuId stuId,p.courseId courseId FROM statu s JOIN paper p ON s.paperId=p.paperId WHERE s.conditionId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,conditionId);
            //执行sql
            rs=pstmt.executeQuery();
            //判断结果集中是否有值
            if (rs.next()){
                //将获得的值保存到map集合中
                map.put("stuId",rs.getString("stuId"));
                map.put("courseId",rs.getInt("courseId"));
                //返回map
                return map;
            }
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空
        return null;
    }

    /**
     * 阅卷后添加补考信息
     *
     * @param stuId
     * @param courseId
     */
    @Override
    public void addReexams(String stuId, int courseId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        try {
            //实例化连接对象
            conn= JdbcUtils.getConnection();
            //创建sql
            String sql="INSERT INTO reexams(stuId,courseId) VALUES(?,?)";
            //实例化连接对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setString(1,stuId);
            pstmt.setInt(2,courseId);
            //执行sql
            pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(null,pstmt,conn);
        }
    }

    /**
     * 初始化难易程度数据
     *
     * @param conditionId
     */
    @Override
    public boolean initializeAnalysis(int conditionId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        //定义一个布尔变量
        boolean boo=true;
        //定义结果集对象
        ResultSet rs=null;
        try {
            //实例化连接对象
            conn=JdbcUtils.getConnection();
            //查询试题难易表中是否有对应试卷的难易数据行
            String sql="SELECT COUNT(*) as counts FROM analysis WHERE (SELECT paperId FROM statu WHERE conditionId=?)=paperId";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,conditionId);
            //执行sql
            rs=pstmt.executeQuery();
            //判断结果集是否有值
            if (rs.next()){
                //判断行数是否为0
                if (rs.getInt("counts")!=0){
                    //让布尔值为false
                    boo=false;
                    //返回布尔值
                    return boo;
                }
            }
            //判断布尔值是否为true
            if (boo){
                //定义一个变量接收题目组字符串组
                String subjectIds="";
                //定义一个变量接收试卷编号
                int paperId=0;
                //定义一个变量接收编辑班级编号
                int classId=0;
                //清空结果集对象
                rs=null;
                //清空预编译对象
                pstmt=null;
                //创建sql语句
                String sqls="SELECT paper.subjectIds subjectIds,statu.paperId paperId,statu.classId classId FROM statu JOIN paper ON statu.paperId=paper.paperId WHERE conditionId=?";
                //实例化预编译对象
                pstmt=conn.prepareStatement(sqls);
                //给占位符赋值
                pstmt.setInt(1,conditionId);
                //执行sql
                rs=pstmt.executeQuery();
                //判断结果集是否有值
                if (rs.next()){
                    //给对象中的变量赋值
                    subjectIds=rs.getString("subjectIds");
                    paperId=rs.getInt("paperId");
                    classId=rs.getInt("classId");
                }
                //通过“,”分割字符串
                String[] chars=subjectIds.split(",");
                //遍历
                for (String c:chars) {
                    //调用存储数据的方法
                    this.initializeData(paperId,classId,c);
                }
            }
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回布尔变量
        return boo;
    }

    /**
     * 初始化难易程度数据，该方法有上面方法调用
     *
     * @param paperId 试卷编号
     * @param classId 班级编号
     * @param subjectId 试题编号
     */
    @Override
    public void initializeData(int paperId, int classId, String subjectId) {
        //定义编号保存试题编号
        int subjectIdss=Integer.parseInt(subjectId);
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        try {
            //实例化连接对象
            conn= JdbcUtils.getConnection();
            //创建sql
            String sql="INSERT INTO analysis(subjectId,classId,rightNum,accRate,paperId) VALUES(?,?,?,?,?)";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,subjectIdss);
            pstmt.setInt(2,classId);
            pstmt.setInt(3,0);
            pstmt.setDouble(4,0.0);
            pstmt.setInt(5,paperId);
            //执行sql
            pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(null,pstmt,conn);
        }
    }

    /**
     * 查询班级人数的方法
     *
     * @param conditionId
     * @return
     */
    @Override
    public int findStuNum(int conditionId) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        //定义结果集对象
        ResultSet rs=null;
        //定义变量接收班级人数
        int studentCount=0;
        try {
            //创建连接对象
            conn=JdbcUtils.getConnection();
            //创建sql语句
            String sql="SELECT c.studentCount studentCount FROM class c JOIN statu s ON c.classId=s.classId WHERE s.conditionId=?";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,conditionId);
            //执行sql
            rs=pstmt.executeQuery();
            //判断结果集是否有值
            if (rs.next()){
                //将值保存到对象变量中
                studentCount=rs.getInt("studentCount");
                //返回该变量
                return studentCount;
            }
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(rs,pstmt,conn);
        }
        return 0;
    }

    /**
     * 更新试题难易表
     *
     * @param conditionId
     * @param correctId
     */
    @Override
    public void updateAnalysis(int conditionId, String correctId,int stuNum) {
        //定义连接对象
        Connection conn=null;
        //定义预编译对象
        PreparedStatement pstmt=null;
        try {
            //实例化连接对象
            conn=JdbcUtils.getConnection();
            //创建sql语句
            String sql="UPDATE analysis SET rightNum=(rightNum+1)," +
                    "accRate=(rightNum/?) " +
                    "WHERE subjectId=? AND paperId=(SELECT paperId FROM statu WHERE conditionId=?)";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给占位符赋值
            pstmt.setInt(1,stuNum);
            pstmt.setString(2,correctId);
            pstmt.setInt(3,conditionId);
            //执行sql
            pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //关闭流
            JdbcUtils.close(null,pstmt,conn);
        }
    }

}
